A graphical user interface (GUI) is a type of interface that uses graphical image elements to allow users to interact with and control a computing or electronic device. Instead of requiring a user to type commands using some form of text, the GUI control and navigation of the interface is based upon direct manipulation of graphical elements.
There are many types of computing applications that utilize graphical user interfaces to enable users to visually edit and modify the configuration of objects on a screen. For example, many types of drawing and computer aided design (CAD) tools are implemented using GUI-style interfaces. The GUI interface permits the user to visually manipulate the configuration of objects that are being drawn and displayed on the screen of a display device. In many of these GUIs, the user will select an object and can manipulate or edit the object using a pointing device such as a mouse pointer. For operations that involve moving an object, the GUI allows the user to manipulate an object by dragging and dropping the object from a first location to a second location. Dragging is commonplace in modern graphical editors and is accomplished by having the users select the object(s) they intend to move and initiate some sort of “move” command where the selected objects appear to be attached or glued to the pointer as it moves across the screen.
When presenting images of objects using a GUI, it is very helpful to the user if the visual representation displayed to the user is a close approximation of the end result of the user's actions. This correspondence between the visual representation and the actual end result is often referred to as “WYSIWYG”, and is a desirable aspect of many GUI-based systems. This is because it is important to provide visual feedback to the user regarding where the objects will end up once the move operation is completed. In addition, the GUI should provide visual continuity to the user during the ghosting of the objects as the user moves the pointer across the screen. This lowers the cognitive load on the user, since the user does not have to figure out where the object will end up, as well as increasing the user's confidence in the tool.
However, problems may occur if the user commits an error or creates some sort of configuration violation when manipulating an object using the GUI. For example, in some applications, objects are not permitted to be placed into certain locations, and it is a violation if the user attempts to move an object into a space that does not permit the placement of that object in that space. Therefore, when moving an object, it is desirable to let the user to see where the objects would end up on the screen if the user completes the move operation, but the intended move operation by the user may cause the object to be moved to an impermissible location on the screen. It is desirable to let the user see, at all times, where the objects would end up on the screen if the user completes the move operation, but the problem is that the user may have moved the object to an impermissible location.
This issue is particularly problematic in the field of electronic circuit designs. Conventional electronic design processes proceed sequentially through a schematic design stage to determine the schematic design of an electronic design, a physical design stage to construct the layout of the electronic design, and a verification stage at which various verification processes, such as design rule checking and physical verification, are performed to determine whether the electronic design complies with certain set of constraints, design rules, requirements, or goals (collectively constraints). Any violations identified during the verification stage may require a costly and often time-consuming process to resolve such violations. For example, a layout designer may have to return to the physical design to move certain objects or to reroute certain interconnects in order to satisfy a spacing constraint and re-submit the revised electronic design to the verification modules or design rule check engines to determine whether the revised electronic design satisfies the prescribed constraints or constraints. As a result, the electronic design process may involve an iterative process where designers loop among various stages of the process, hoping that the electronic design may be finally signed off for tapeout. In addition, a layout designer often does not know whether any portion of the layout violates certain constraints until the layout is complete and ready for verification. The advent of more complex constraints simply exacerbates the problems. The recent advances in very deep sub-micron (VDSM) integrated circuits (ICs) have exacerbated the issues in the physical design methodology process of electronic circuits.
Therefore, what is needed is an improved approach to implement interactive placement of objects in a GUI for electronic designs, that efficiently permits automatic visualization and placement of objects in legal locations. The solution should be able to address and handle constraints that exist for modern deep-submicron design processes.